Lecture 2 Analysis: Arrays & Memory Anatomy

Section 1: Deconstructing the 4 Stages of Compilation

In Lecture 2, David Malan unveils the mechanical pipeline that transforms human-readable C source code into executable binary machine code. Rather than viewing make or clang as a singular black-box operation, the process is forensically dissected into four sequential architectural stages:

===================================================================================
             CLANG COMPILATION LIFECYCLE (4-STAGE PIPELINE)
===================================================================================

  [ 1. PREPROCESSING ] ──> Expands #include <stdio.h> and replaces #define macros
          │
          ▼
  [ 2. COMPILING ]     ──> Translates bare C syntax into Assembly instructions (.s)
          │
          ▼
  [ 3. ASSEMBLING ]    ──> Converts Assembly instructions into Object Code (.o)
          │
          ▼
  [ 4. LINKING ]       ──> Merges object files & external dynamic libraries (libc)
          │
          ▼
  [ EXECUTABLE (a.out) ] ──> Machine-level binary matrix loaded directly into RAM

===================================================================================

• Preprocessing: The compiler parses the source file for directives beginning with #. The preprocessor dynamically replaces these directives with the literal contents of external header files.
• Compiling: Translates the expanded preprocessed C code directly into low-level Assembly Language containing explicit processor instructions like MOV, PUSH, CALL.
• Assembling: Converts Assembly language instructions into pure binary Object Code consisting entirely of machine-level 0s and 1s (.o file).
• Linking: Combines multiple object files (e.g., main.o, cs50.o, and system libc libraries) into a single, unified executable binary a.out.

Section 2: Physical Memory Anatomy & Arrays

Malan conceptualizes Random Access Memory (RAM) as an expansive physical grid of memory cells, where each discrete cell represents exactly one byte (1 Byte = 8 bits).

• Variable Storage: Instantiating a char allocates 1 byte of physical stack memory, whereas an int allocates 4 contiguous bytes.
• The Birth of Arrays: When managing groups of related data such as test scores, instead of allocating isolated variables, we deploy array data structures int scores[3];.
• Architectural Advantage: Arrays enforce contiguous memory allocation, allowing instantaneous index-based element access via pointer offset calculation.

Section 3: The Truth About Strings in C

In bare-metal C, there is no primitive string data type. A string is architecturally implemented as an array of characters (char) stored contiguously in memory, terminated mandatorily by a null character (Null Terminator) whose ASCII numerical value is 0 (\0).

===================================================================================
             MEMORY ANATOMY OF A STRING ("HI!")
===================================================================================

  Index:       [0]      [1]      [2]      [3]
  Character:   'H'      'I'      '!'      '\0'
  ASCII Value:  72       73       33        0
  Memory Addr: 0x120    0x121    0x122    0x123  (Contiguous bytes)

===================================================================================

Section 4: CLI Arguments & Cryptography

Command-line execution depends on the rigid signature of main(int argc, string argv[]).

• argc (Argument Count): An integer representing the total count of command-line parameters passed to the executable.
• argv (Argument Vector): An array of strings containing the exact argument parameters.
• Caesar Cipher: Shifts alphabetical characters by a fixed numerical key (p + k) % 26.
• Substitution Cipher: Replaces each cleartext character against a complex 26-character scrambled substitution key.